import {toast} from '@/utils/lib'
class Util {
	// 增加代理函数名错误检测
	constructor() {
		return new Proxy(this, {
			get(target, key) {
				if (key in target) {
					return target[key]
				} else {
					toast('工具函数名不存在')
				}
			}
		})
	}

	// 深拷贝
	deepClone(source) {
		if (!source && typeof source !== 'object') {
			throw new Error('error arguments', 'shallowClone')
		}
		const targetObj = source.constructor === Array ? [] : {}
		for (const keys in source) {
			if (source.hasOwnProperty(keys)) {
				if (source[keys] && typeof source[keys] === 'object') {
					targetObj[keys] = source[keys].constructor === Array ? [] : {}
					targetObj[keys] = this.deepClone(source[keys])
				} else {
					targetObj[keys] = source[keys]
				}
			}
		}
		return targetObj
	}

	// 初始化请求路径,将path和params拼接成url
	initUrl(url) {
		if (!url.params) {
			return url.path
		} else {
			let querySrc = Object.keys(url.params).reduce((src, key, index) => {
				src += index === 0 ? `${key}=${url.params[key]}` : `&${key}=${url.params[key]}`
				return src
			}, '?')
			return url.path + querySrc
		}
	}
	// 获取当月多少天
	getMonthDays() {
		let year = new Date().getFullYear()
		let month = (new Date().getMonth() + 1)
		return new Date(year, month, 0).getDate() // 最后一个参数为0,意为获取当月一共多少天
	}

	// 获取文件格式
	getFileType(file) {
		let index = file.lastIndexOf('.')
		return file.slice(index + 1)
	}

	// 防抖
	debounce(fn, delay) {
		let timer
		return (...args) => {
			//必须上一次执行完成才会触发
			if (timer) {
				clearTimeout(timer)
				timer = null
			}
			timer = setTimeout(() => {
				fn(...args)
			}, delay)
		}
	}

	//节流
	throttle(fn, delay = 500) {
		let timer, lastTime
		return (...args) => {
			let nowTime = new Date().getTime()
			let space = nowTime - lastTime
			//不是首次
			if (lastTime && space < delay) {
				timer && clearTimeout(timer)
				lastTime = nowTime
				timer = setTimeout(() => {
					fn(...args)
				}, delay - space)
			} else {
				lastTime = nowTime
				fn(...args)
				timer && clearTimeout(timer)
			}
		}
	}



	// 判断是否是空对象{}
	isEmptyObj(obj) {
		return obj !== null && typeof obj === 'object' && !Array.isArray(obj) && (Object.keys(obj).length === 0)
	}

	// 判断不是空对象
	isNotEmptyObj(obj) {
		return !this.isEmpty(obj)
	}

	// 是否是数组[]
	isEmptyArr(Arr) {
		return Array.isArray(Arr) && Arr.length === 0
	}
	// 是否是空，undefined,null,"",{},[]
	isEmpty(value) {
		if (!value && value !== 0) {
			return true
		} else {
			if (Object.prototype.toString.call(value) === '[object Array]') {
				return value.length === 0
			}
			if (Object.prototype.toString.call(value) === '[object Object]') {
				return Object.keys(value).length === 0
			}
		}
		return false
	}

	// 是否是JSON字符串
	isJSONStr(str) {
		try {
			if (JSON.parse(str) instanceof Object) {
				return true
			}
		} catch (error) {
			// console.log(error)
			return false
		}
	}

	// 是否是对象
	isObject(obj) {
		return obj !== null && typeof obj === 'object'
	}
	//是否是数组
	isArray(arr) {
		return Array.isArray(arr)
	}
	// 是否未定义
	isUndef(v) {
		return v === undefined || v === null
	}
	// 是否已定义
	isDef(v) {
		return v !== undefined && v !== null
	}

	// 去掉最后字符
	deleteLastStr(str, num = 1) {
		return str.substring(0, str.length - num)
	}

	//找到最后一个符合条件的下标
	findLastIndex(arr, key, target) {
		let currIndex
		if (arr instanceof Array) {
			arr.forEach((item, index) => {
				if (item[key] === target) {
					currIndex = index
				}
			})
			return currIndex
		} else {
			return
		}
	}

	//标准化lable
	normalizeLabel(label) {
		if (!label) {
			return
		}
		let labels = label.slice(1, -1).split(",")
		return labels.map(label => {
			let index = label.indexOf('|')
			return {
				labelType: label.slice(index + 1),
				labelText: label.slice(0, index)
			}
		})
	}

	// forEach封装，处理特殊需求
	forEach(obj, fn) {
		if (typeof(obj) === 'object') {
			if (Array.isArray(obj)) {
				obj.forEach((elem) => {
					fn(elem)
				})
			} else {
				Object.keys(obj).forEach((elem) => {
					fn(elem, obj[elem])
				})
			}
		} else {
			return
		}
	}
	//表单验证
	validateForm(ruleForm,rules) {
		return new Promise(resolve => {
			let errMsg = ""
			this.forEach(rules, (key, value) => {
				if (!errMsg) {
					let formValue = ruleForm[key]
					value.forEach(item => {
						if (item.required) {
							if (!formValue) {
								errMsg = item.msg
							}
						}
					})
				}
			})
			if(errMsg){
				toast(errMsg)
				resolve(false)
			}else{
				resolve(true)
			}
		})
	}
	
	getDuration(time){
		let d=time.split(":")
		if(d.length===2){
			return d[0]*60+(+d[1])
		}
		else if(d.length===3){
			return d[0]*60+d[1]*60
		}
		
	}
}
export default new Util()
